package com.dubious.interview.euler.incomplete;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashSet;
import java.util.Set;

public class Problem388 {

    /**
     * Consider all lattice points (a,b,c) with 0  a,b,c  N.
     * 
     * From the origin O(0,0,0) all lines are drawn to the other lattice points.
     * Let D(N) be the number of distinct such lines.
     * 
     * You are given that D(1 000 000) = 831909254469114121.
     * Find D(10^10). Give as your answer the first nine digits followed by the last nine digits.
     */
    public static long run(long n)
    {
        // strategy: I believe this problem is equivalent to finding all unique 
        // normalizations of these drawn lines
        // but this would be too difficult to calculate with such a large input.
        // can we find a pattern?  Does it have something to do with Pascale's Triangle?
        Set<Point> normalizedLines = new HashSet<Point>();
        
        for(int i = 0; i <= n; i++)
        {
            for(int j = 0; j <= n; j++)
            {
                for(int k = 0; k <= 0; k++)
                {
                    // find length
                    BigDecimal length = new BigDecimal(Math.sqrt(i*i + j*j + k*k));
                    if(length.doubleValue() > 0)
                    {
                        normalizedLines.add(
                                new Point(
                                        new BigDecimal(i).divide(length, 10, RoundingMode.UP), 
                                        new BigDecimal(j).divide(length, 10, RoundingMode.UP), 
                                        new BigDecimal(k).divide(length, 10, RoundingMode.UP)));
                    }
                }
            }
        }
        
        return normalizedLines.size();
    }
    
    private static class Point
    {
        private BigDecimal x;
        private BigDecimal y;
        private BigDecimal z;
        
        private Point(BigDecimal x, BigDecimal y, BigDecimal z)
        {
            this.x = x;
            this.y = y;
            this.z = z;
        }
        
        @Override
        public int hashCode()
        {
            return x.multiply(y).multiply(z).multiply(BigDecimal.valueOf(Integer.MAX_VALUE)).intValue();
        }
        
        @Override
        public boolean equals(Object other)
        {
            if(!(other instanceof Point))
            {
                return false;
            }
            
            Point otherPoint = (Point)other;
            return x.equals(otherPoint.x) && y.equals(otherPoint.y) && z.equals(otherPoint.z);
        }
        
        @Override
        public String toString()
        {
            return "x=" + x.doubleValue() + ",y=" + y.doubleValue() + ",z=" + z.doubleValue();
        }
    }
    
/**
Consider the two dimensional version of this problem.

n = 2
y y y
x x y
x x y
total lines = 8
unique lines = 5

n = 3
y y y y
x y x y
x x y y
x x x y
total lines = 15
unique lines = 9

n = 4
y y y y y
x y y x y
x x x y y
x x x y y
x x x x y
total lines = 24
unique lines = 13

n = 5
y y y y y y
x y y y x y
x y y x y y
x x x y y y
x x x y y y
x x x x x y
total lines = 35
unique lines = 21

n = 6
y y y y y y y
x y y y y x y
x y x y x y y
x x x x y y y
x x x x x y y
x x x x y y y
x x x x x x y
total lines = 48
unique lines = 27

n = 7
y y y y y y y y (7 + 1)
x y y y y y x (5)
x y y y y x (4)
x y x y x (2)
x x x x
x x x
x x
x
total lines = 63
unique lines = 37

n = 8
y y y y y y y y y (8 + 1)
x y y y y y y x (6)
x y y x x y x (3)
x y y y y x (4)
x x x x x
x x x x
x x x
x x
x
total lines = 80
unique lines = 45

n = 9
y y y y y y y y y y (9 + 1)
x y y y y y y y x (7)
x y y y y y y x (6)
x y x x x y x (2)
x y y y y x (4)
x x x x x
x x x x
x x x
x x
x
total lines = 100
unique lines = 57
*/
}
